home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / compile_to_jvm7.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  20.7 KB  |  755 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9. void r308clear_all(T308* C){
  10. T0* _value=NULL;
  11. /*[IRF3.6set_all_with*/{T308* C1=C;
  12. T0* b1=_value;
  13. r778set_all_with((((T308*)C1))->_storage/*4*/,b1,(((T308*)C1))->_upper/*12*/);
  14. }/*]*/
  15. }
  16. /*No:FIXED_ARRAY[RUN_FEATURE].set_all_with*/
  17. void r308make(T308* C,int a1){
  18. /*IF*/if ((a1)==(0)) {
  19. C->_upper=-(1);
  20. }
  21.  else if (((((T308*)C))->_capacity/*8*/)==(0)) {
  22. C->_storage=calloc(a1,sizeof(T0*));
  23. C->_capacity=a1;
  24. C->_upper=(a1)-(1);
  25. }
  26.  else if (((((T308*)C))->_capacity/*8*/)<(a1)) {
  27. C->_storage=calloc(a1,sizeof(T0*));
  28. C->_capacity=a1;
  29. C->_upper=(a1)-(1);
  30. }
  31. else {
  32. C->_upper=(a1)-(1);
  33. r308clear_all(C);
  34. }
  35. /*FI*/}
  36. int r308fast_has(T308* C,T0* a1){
  37. int R=0;
  38. /*IF*/if ((r308count(C))>(0)) {
  39. R=(r308fast_index_of(C,a1))<=((((T308*)C))->_upper/*12*/);
  40. }
  41. /*FI*/return R;
  42. }
  43. T0* r308item(T308* C,int a1){
  44. T0* R=NULL;
  45. R=((((T308*)C))->_storage/*4*/)[a1];
  46. return R;
  47. }
  48. void r308resize(T308* C,int a1){
  49. T0* _elt_default=NULL;
  50. int _i=0;
  51. int _new_capacity=0;
  52. /*IF*/if ((a1)<=(r308count(C))) {
  53. C->_upper=(a1)-(1);
  54. }
  55. else {
  56. _new_capacity=a1;
  57. /*IF*/if (((((T308*)C))->_capacity/*8*/)<(_new_capacity)) {
  58. /*IF*/if (((((T308*)C))->_capacity/*8*/)==(0)) {
  59. C->_storage=calloc(_new_capacity,sizeof(T0*));
  60. }
  61. else {
  62. C->_storage=r778realloc((((T308*)C))->_storage/*4*/,(((T308*)C))->_capacity/*8*/,_new_capacity);
  63. }
  64. /*FI*/C->_capacity=_new_capacity;
  65. }
  66. /*FI*/_new_capacity=(((T308*)C))->_upper/*12*/;
  67. C->_upper=(a1)-(1);
  68. _i=(((T308*)C))->_upper/*12*/;
  69. while (!((_i)==(_new_capacity))) {
  70. /*[IRF3.6put*/{T308* C1=C;
  71. T0* b1=_elt_default;
  72. int b2=_i;
  73. ((((T308*)C1))->_storage/*4*/)[b2]=(b1);
  74. }/*]*/
  75. _i=(_i)-(1);
  76. }
  77. }
  78. /*FI*/}
  79. /*No:FIXED_ARRAY[RUN_FEATURE].clear*/
  80. /*No:FIXED_ARRAY[RUN_FEATURE].storage*/
  81. /*No:FIXED_ARRAY[RUN_FEATURE].capacity*/
  82. void r308with_capacity(T308* C,int a1){
  83. /*IF*/if (((((T308*)C))->_capacity/*8*/)<(a1)) {
  84. C->_storage=calloc(a1,sizeof(T0*));
  85. C->_capacity=a1;
  86. }
  87. /*FI*/C->_upper=-(1);
  88. }
  89. int r308fast_index_of(T308* C,T0* a1){
  90. int R=0;
  91. R=r778fast_index_of((((T308*)C))->_storage/*4*/,a1,(((T308*)C))->_upper/*12*/);
  92. return R;
  93. }
  94. /*No:FIXED_ARRAY[RUN_FEATURE].put*/
  95. /*No:FIXED_ARRAY[RUN_FEATURE].upper*/
  96. void r308add_last(T308* C,T0* a1){
  97. int _new_capacity=0;
  98. /*IF*/if ((((((T308*)C))->_upper/*12*/)+(1))<=(((((T308*)C))->_capacity/*8*/)-(1))) {
  99. C->_upper=((((T308*)C))->_upper/*12*/)+(1);
  100. }
  101.  else if (((((T308*)C))->_capacity/*8*/)==(0)) {
  102. C->_storage=calloc(2,sizeof(T0*));
  103. C->_capacity=2;
  104. C->_upper=0;
  105. }
  106. else {
  107. _new_capacity=(2)*((((T308*)C))->_capacity/*8*/);
  108. C->_storage=r778realloc((((T308*)C))->_storage/*4*/,(((T308*)C))->_capacity/*8*/,_new_capacity);
  109. C->_capacity=_new_capacity;
  110. C->_upper=((((T308*)C))->_upper/*12*/)+(1);
  111. }
  112. /*FI*//*[IRF3.6put*/{T308* C1=C;
  113. T0* b1=a1;
  114. int b2=(((T308*)C))->_upper/*12*/;
  115. ((((T308*)C1))->_storage/*4*/)[b2]=(b1);
  116. }/*]*/
  117. }
  118. int r308count(T308* C){
  119. int R=0;
  120. R=((((T308*)C))->_upper/*12*/)+(1);
  121. return R;
  122. }
  123. /*No:ARRAY[LOCAL_NAME1].clear_all*/
  124. /*No:ARRAY[LOCAL_NAME1].set_all_with*/
  125. void r733make(T733* C,int a1,int a2){
  126. int _needed=0;
  127. C->_lower=a1;
  128. C->_upper=a2;
  129. _needed=((a2)-(a1))+(1);
  130. /*IF*/if ((_needed)>(0)) {
  131. /*IF*/if (((((T733*)C))->_capacity/*8*/)<(_needed)) {
  132. /*IF*/if (((((T733*)C))->_capacity/*8*/)==(0)) {
  133. C->_storage=calloc(_needed,sizeof(T0*));
  134. }
  135. else {
  136. C->_storage=calloc(_needed,sizeof(T0*));
  137. }
  138. /*FI*/C->_capacity=_needed;
  139. }
  140. else {
  141. /*[IRF3.6clear_all*/{T733* C1=C;
  142. T0* __value=NULL;
  143. /*[IRF3.6set_all_with*/{T733* C2=C1;
  144. T0* c1=__value;
  145. r731set_all_with((((T733*)C2))->_storage/*4*/,c1,((((T733*)C2))->_upper/*12*/)-((((T733*)C2))->_lower/*16*/));
  146. }/*]*/
  147. }/*]*/
  148. }
  149. /*FI*/}
  150. /*FI*/}
  151. T0* r733item(T733* C,int a1){
  152. T0* R=NULL;
  153. R=((((T733*)C))->_storage/*4*/)[(a1)-((((T733*)C))->_lower/*16*/)];
  154. return R;
  155. }
  156. /*No:ARRAY[LOCAL_NAME1].storage*/
  157. T0* r733twin(T733* C){
  158. T0* R=NULL;
  159. R=malloc(sizeof(*C));
  160. *((T733*)R)=M733;
  161. r733copy(((T733*)R),((T0*)C));
  162. return R;
  163. }
  164. /*No:ARRAY[LOCAL_NAME1].capacity*/
  165. void r733copy(T733* C,T0* a1){
  166. int _needed_capacity=0;
  167. C->_lower=(((T733*)((T733*)a1)))->_lower/*16*/;
  168. C->_upper=(((T733*)((T733*)a1)))->_upper/*12*/;
  169. _needed_capacity=(((((T733*)C))->_upper/*12*/)-((((T733*)C))->_lower/*16*/))+(1);
  170. /*IF*/if (((((T733*)C))->_capacity/*8*/)<(_needed_capacity)) {
  171. C->_capacity=_needed_capacity;
  172. C->_storage=calloc((((T733*)C))->_capacity/*8*/,sizeof(T0*));
  173. }
  174. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  175. r731copy_from((((T733*)C))->_storage/*4*/,(((T733*)((T733*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  176. }
  177. /*FI*/}
  178. /*No:ARRAY[LOCAL_NAME1].lower*/
  179. /*No:ARRAY[LOCAL_NAME1].put*/
  180. /*No:ARRAY[LOCAL_NAME1].upper*/
  181. int r733count(T733* C){
  182. int R=0;
  183. R=(((((T733*)C))->_upper/*12*/)-((((T733*)C))->_lower/*16*/))+(1);
  184. return R;
  185. }
  186. void r733add_last(T733* C,T0* a1){
  187. int _new_capacity=0;
  188. /*IF*/if (((((T733*)C))->_capacity/*8*/)<((r733count(C))+(1))) {
  189. /*IF*/if (((((T733*)C))->_capacity/*8*/)==(0)) {
  190. C->_capacity=16;
  191. C->_storage=calloc((((T733*)C))->_capacity/*8*/,sizeof(T0*));
  192. }
  193. else {
  194. _new_capacity=(2)*((((T733*)C))->_capacity/*8*/);
  195. C->_storage=r731realloc((((T733*)C))->_storage/*4*/,(((T733*)C))->_capacity/*8*/,_new_capacity);
  196. C->_capacity=_new_capacity;
  197. }
  198. /*FI*/}
  199. /*FI*/C->_upper=((((T733*)C))->_upper/*12*/)+(1);
  200. /*[IRF3.6put*/{T733* C1=C;
  201. T0* b1=a1;
  202. int b2=(((T733*)C))->_upper/*12*/;
  203. ((((T733*)C1))->_storage/*4*/)[(b2)-((((T733*)C1))->_lower/*16*/)]=(b1);
  204. }/*]*/
  205. }
  206. T0* r733first(T733* C){
  207. T0* R=NULL;
  208. R=r733item(C,(((T733*)C))->_lower/*16*/);
  209. return R;
  210. }
  211. T0* r247item(T247* C,int a1){
  212. T0* R=NULL;
  213. R=((((T247*)C))->_storage/*4*/)[(a1)-((((T247*)C))->_lower/*16*/)];
  214. return R;
  215. }
  216. /*No:ARRAY[WHEN_ITEM_1].storage*/
  217. T0* r247twin(T247* C){
  218. T0* R=NULL;
  219. R=malloc(sizeof(*C));
  220. *((T247*)R)=M247;
  221. r247copy(((T247*)R),((T0*)C));
  222. return R;
  223. }
  224. /*No:ARRAY[WHEN_ITEM_1].capacity*/
  225. void r247copy(T247* C,T0* a1){
  226. int _needed_capacity=0;
  227. C->_lower=(((T247*)((T247*)a1)))->_lower/*16*/;
  228. C->_upper=(((T247*)((T247*)a1)))->_upper/*12*/;
  229. _needed_capacity=(((((T247*)C))->_upper/*12*/)-((((T247*)C))->_lower/*16*/))+(1);
  230. /*IF*/if (((((T247*)C))->_capacity/*8*/)<(_needed_capacity)) {
  231. C->_capacity=_needed_capacity;
  232. C->_storage=calloc((((T247*)C))->_capacity/*8*/,sizeof(T0*));
  233. }
  234. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  235. r497copy_from((((T247*)C))->_storage/*4*/,(((T247*)((T247*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  236. }
  237. /*FI*/}
  238. /*No:ARRAY[WHEN_ITEM_1].lower*/
  239. /*No:ARRAY[WHEN_ITEM_1].put*/
  240. /*No:ARRAY[WHEN_ITEM_1].upper*/
  241. int r247count(T247* C){
  242. int R=0;
  243. R=(((((T247*)C))->_upper/*12*/)-((((T247*)C))->_lower/*16*/))+(1);
  244. return R;
  245. }
  246. void r247add_last(T247* C,T0* a1){
  247. int _new_capacity=0;
  248. /*IF*/if (((((T247*)C))->_capacity/*8*/)<((r247count(C))+(1))) {
  249. /*IF*/if (((((T247*)C))->_capacity/*8*/)==(0)) {
  250. C->_capacity=16;
  251. C->_storage=calloc((((T247*)C))->_capacity/*8*/,sizeof(T0*));
  252. }
  253. else {
  254. _new_capacity=(2)*((((T247*)C))->_capacity/*8*/);
  255. C->_storage=r497realloc((((T247*)C))->_storage/*4*/,(((T247*)C))->_capacity/*8*/,_new_capacity);
  256. C->_capacity=_new_capacity;
  257. }
  258. /*FI*/}
  259. /*FI*/C->_upper=((((T247*)C))->_upper/*12*/)+(1);
  260. /*[IRF3.6put*/{T247* C1=C;
  261. T0* b1=a1;
  262. int b2=(((T247*)C))->_upper/*12*/;
  263. ((((T247*)C1))->_storage/*4*/)[(b2)-((((T247*)C1))->_lower/*16*/)]=(b1);
  264. }/*]*/
  265. }
  266. T0* r948item(T948* C,int a1){
  267. T0* R=NULL;
  268. R=((((T948*)C))->_storage/*0*/)[(a1)-((((T948*)C))->_lower/*12*/)];
  269. return R;
  270. }
  271. /*No:ARRAY[IFTHEN].storage*/
  272. T0* r948twin(T948* C){
  273. T0* R=NULL;
  274. R=malloc(sizeof(*C));
  275. *((T948*)R)=M948;
  276. r948copy(((T948*)R),((T0*)C));
  277. return R;
  278. }
  279. /*No:ARRAY[IFTHEN].capacity*/
  280. void r948copy(T948* C,T0* a1){
  281. int _needed_capacity=0;
  282. C->_lower=(((T948*)((T948*)a1)))->_lower/*12*/;
  283. C->_upper=(((T948*)((T948*)a1)))->_upper/*8*/;
  284. _needed_capacity=(((((T948*)C))->_upper/*8*/)-((((T948*)C))->_lower/*12*/))+(1);
  285. /*IF*/if (((((T948*)C))->_capacity/*4*/)<(_needed_capacity)) {
  286. C->_capacity=_needed_capacity;
  287. C->_storage=calloc((((T948*)C))->_capacity/*4*/,sizeof(T0*));
  288. }
  289. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  290. r191copy_from((((T948*)C))->_storage/*0*/,(((T948*)((T948*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  291. }
  292. /*FI*/}
  293. /*No:ARRAY[IFTHEN].lower*/
  294. /*No:ARRAY[IFTHEN].put*/
  295. /*No:ARRAY[IFTHEN].upper*/
  296. int r948count(T948* C){
  297. int R=0;
  298. R=(((((T948*)C))->_upper/*8*/)-((((T948*)C))->_lower/*12*/))+(1);
  299. return R;
  300. }
  301. void r948add_last(T948* C,T0* a1){
  302. int _new_capacity=0;
  303. /*IF*/if (((((T948*)C))->_capacity/*4*/)<((r948count(C))+(1))) {
  304. /*IF*/if (((((T948*)C))->_capacity/*4*/)==(0)) {
  305. C->_capacity=16;
  306. C->_storage=calloc((((T948*)C))->_capacity/*4*/,sizeof(T0*));
  307. }
  308. else {
  309. _new_capacity=(2)*((((T948*)C))->_capacity/*4*/);
  310. C->_storage=r191realloc((((T948*)C))->_storage/*0*/,(((T948*)C))->_capacity/*4*/,_new_capacity);
  311. C->_capacity=_new_capacity;
  312. }
  313. /*FI*/}
  314. /*FI*/C->_upper=((((T948*)C))->_upper/*8*/)+(1);
  315. /*[IRF3.6put*/{T948* C1=C;
  316. T0* b1=a1;
  317. int b2=(((T948*)C))->_upper/*8*/;
  318. ((((T948*)C1))->_storage/*0*/)[(b2)-((((T948*)C1))->_lower/*12*/)]=(b1);
  319. }/*]*/
  320. }
  321. /*No:ARRAY[RUN_FEATURE_2].clear_all*/
  322. /*No:ARRAY[RUN_FEATURE_2].set_all_with*/
  323. void r280force(T280* C,T0* a1,int a2){
  324. /*IF*/if (((((T280*)C))->_upper/*12*/)<(a2)) {
  325. r280resize(C,(((T280*)C))->_lower/*16*/,a2);
  326. }
  327.  else if ((a2)<((((T280*)C))->_lower/*16*/)) {
  328. r280resize(C,a2,(((T280*)C))->_upper/*12*/);
  329. }
  330. /*FI*//*[IRF3.6put*/{T280* C1=C;
  331. T0* b1=a1;
  332. int b2=a2;
  333. ((((T280*)C1))->_storage/*4*/)[(b2)-((((T280*)C1))->_lower/*16*/)]=(b1);
  334. }/*]*/
  335. }
  336. void r280make(T280* C,int a1,int a2){
  337. int _needed=0;
  338. C->_lower=a1;
  339. C->_upper=a2;
  340. _needed=((a2)-(a1))+(1);
  341. /*IF*/if ((_needed)>(0)) {
  342. /*IF*/if (((((T280*)C))->_capacity/*8*/)<(_needed)) {
  343. /*IF*/if (((((T280*)C))->_capacity/*8*/)==(0)) {
  344. C->_storage=calloc(_needed,sizeof(T0*));
  345. }
  346. else {
  347. C->_storage=calloc(_needed,sizeof(T0*));
  348. }
  349. /*FI*/C->_capacity=_needed;
  350. }
  351. else {
  352. /*[IRF3.6clear_all*/{T280* C1=C;
  353. T0* __value=NULL;
  354. /*[IRF3.6set_all_with*/{T280* C2=C1;
  355. T0* c1=__value;
  356. r579set_all_with((((T280*)C2))->_storage/*4*/,c1,((((T280*)C2))->_upper/*12*/)-((((T280*)C2))->_lower/*16*/));
  357. }/*]*/
  358. }/*]*/
  359. }
  360. /*FI*/}
  361. /*FI*/}
  362. T0* r280item(T280* C,int a1){
  363. T0* R=NULL;
  364. R=((((T280*)C))->_storage/*4*/)[(a1)-((((T280*)C))->_lower/*16*/)];
  365. return R;
  366. }
  367. void r280resize(T280* C,int a1,int a2){
  368. int _mem=0;
  369. int _up=0;
  370. int _i=0;
  371. T0* _other=NULL;
  372. {T280*n=malloc(sizeof(*n));
  373. *n=M280;
  374. r280make(n,a1,a2);
  375. _other=(T0*)n;
  376. }
  377. _i=r2max((((T280*)C))->_lower/*16*/,(((T280*)((T280*)_other)))->_lower/*16*/);
  378. _up=r2min((((T280*)C))->_upper/*12*/,(((T280*)((T280*)_other)))->_upper/*12*/);
  379. while (!((_i)>(_up))) {
  380. /*[IRF3.6put*/{T280* C1=((T280*)_other);
  381. T0* b1=r280item(C,_i);
  382. int b2=_i;
  383. ((((T280*)C1))->_storage/*4*/)[(b2)-((((T280*)C1))->_lower/*16*/)]=(b1);
  384. }/*]*/
  385. _i=(_i)+(1);
  386. }
  387. *((T280*)(C))=*((T280*)(_other));
  388. }
  389. /*No:ARRAY[RUN_FEATURE_2].storage*/
  390. void r280swap(T280* C,int a1,int a2){
  391. T0* _tmp=NULL;
  392. _tmp=r280item(C,a1);
  393. /*[IRF3.6put*/{T280* C1=C;
  394. T0* b1=r280item(C,a2);
  395. int b2=a1;
  396. ((((T280*)C1))->_storage/*4*/)[(b2)-((((T280*)C1))->_lower/*16*/)]=(b1);
  397. }/*]*/
  398. /*[IRF3.6put*/{T280* C1=C;
  399. T0* b1=_tmp;
  400. int b2=a2;
  401. ((((T280*)C1))->_storage/*4*/)[(b2)-((((T280*)C1))->_lower/*16*/)]=(b1);
  402. }/*]*/
  403. }
  404. /*No:ARRAY[RUN_FEATURE_2].capacity*/
  405. /*No:ARRAY[RUN_FEATURE_2].lower*/
  406. /*No:ARRAY[RUN_FEATURE_2].put*/
  407. /*No:ARRAY[RUN_FEATURE_2].upper*/
  408. int r280count(T280* C){
  409. int R=0;
  410. R=(((((T280*)C))->_upper/*12*/)-((((T280*)C))->_lower/*16*/))+(1);
  411. return R;
  412. }
  413. void r280add_last(T280* C,T0* a1){
  414. int _new_capacity=0;
  415. /*IF*/if (((((T280*)C))->_capacity/*8*/)<((r280count(C))+(1))) {
  416. /*IF*/if (((((T280*)C))->_capacity/*8*/)==(0)) {
  417. C->_capacity=16;
  418. C->_storage=calloc((((T280*)C))->_capacity/*8*/,sizeof(T0*));
  419. }
  420. else {
  421. _new_capacity=(2)*((((T280*)C))->_capacity/*8*/);
  422. C->_storage=r579realloc((((T280*)C))->_storage/*4*/,(((T280*)C))->_capacity/*8*/,_new_capacity);
  423. C->_capacity=_new_capacity;
  424. }
  425. /*FI*/}
  426. /*FI*/C->_upper=((((T280*)C))->_upper/*12*/)+(1);
  427. /*[IRF3.6put*/{T280* C1=C;
  428. T0* b1=a1;
  429. int b2=(((T280*)C))->_upper/*12*/;
  430. ((((T280*)C1))->_storage/*4*/)[(b2)-((((T280*)C1))->_lower/*16*/)]=(b1);
  431. }/*]*/
  432. }
  433. /*No:ARRAY[ARGUMENT_NAME1].clear_all*/
  434. /*No:ARRAY[ARGUMENT_NAME1].set_all_with*/
  435. void r65make(T65* C,int a1,int a2){
  436. int _needed=0;
  437. C->_lower=a1;
  438. C->_upper=a2;
  439. _needed=((a2)-(a1))+(1);
  440. /*IF*/if ((_needed)>(0)) {
  441. /*IF*/if (((((T65*)C))->_capacity/*8*/)<(_needed)) {
  442. /*IF*/if (((((T65*)C))->_capacity/*8*/)==(0)) {
  443. C->_storage=calloc(_needed,sizeof(T0*));
  444. }
  445. else {
  446. C->_storage=calloc(_needed,sizeof(T0*));
  447. }
  448. /*FI*/C->_capacity=_needed;
  449. }
  450. else {
  451. /*[IRF3.6clear_all*/{T65* C1=C;
  452. T0* __value=NULL;
  453. /*[IRF3.6set_all_with*/{T65* C2=C1;
  454. T0* c1=__value;
  455. r24set_all_with((((T65*)C2))->_storage/*4*/,c1,((((T65*)C2))->_upper/*12*/)-((((T65*)C2))->_lower/*16*/));
  456. }/*]*/
  457. }/*]*/
  458. }
  459. /*FI*/}
  460. /*FI*/}
  461. T0* r65item(T65* C,int a1){
  462. T0* R=NULL;
  463. R=((((T65*)C))->_storage/*4*/)[(a1)-((((T65*)C))->_lower/*16*/)];
  464. return R;
  465. }
  466. /*No:ARRAY[ARGUMENT_NAME1].storage*/
  467. T0* r65twin(T65* C){
  468. T0* R=NULL;
  469. R=malloc(sizeof(*C));
  470. *((T65*)R)=M65;
  471. r65copy(((T65*)R),((T0*)C));
  472. return R;
  473. }
  474. /*No:ARRAY[ARGUMENT_NAME1].capacity*/
  475. void r65copy(T65* C,T0* a1){
  476. int _needed_capacity=0;
  477. C->_lower=(((T65*)((T65*)a1)))->_lower/*16*/;
  478. C->_upper=(((T65*)((T65*)a1)))->_upper/*12*/;
  479. _needed_capacity=(((((T65*)C))->_upper/*12*/)-((((T65*)C))->_lower/*16*/))+(1);
  480. /*IF*/if (((((T65*)C))->_capacity/*8*/)<(_needed_capacity)) {
  481. C->_capacity=_needed_capacity;
  482. C->_storage=calloc((((T65*)C))->_capacity/*8*/,sizeof(T0*));
  483. }
  484. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  485. r24copy_from((((T65*)C))->_storage/*4*/,(((T65*)((T65*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  486. }
  487. /*FI*/}
  488. /*No:ARRAY[ARGUMENT_NAME1].lower*/
  489. /*No:ARRAY[ARGUMENT_NAME1].put*/
  490. /*No:ARRAY[ARGUMENT_NAME1].upper*/
  491. int r65count(T65* C){
  492. int R=0;
  493. R=(((((T65*)C))->_upper/*12*/)-((((T65*)C))->_lower/*16*/))+(1);
  494. return R;
  495. }
  496. void r65add_last(T65* C,T0* a1){
  497. int _new_capacity=0;
  498. /*IF*/if (((((T65*)C))->_capacity/*8*/)<((r65count(C))+(1))) {
  499. /*IF*/if (((((T65*)C))->_capacity/*8*/)==(0)) {
  500. C->_capacity=16;
  501. C->_storage=calloc((((T65*)C))->_capacity/*8*/,sizeof(T0*));
  502. }
  503. else {
  504. _new_capacity=(2)*((((T65*)C))->_capacity/*8*/);
  505. C->_storage=r24realloc((((T65*)C))->_storage/*4*/,(((T65*)C))->_capacity/*8*/,_new_capacity);
  506. C->_capacity=_new_capacity;
  507. }
  508. /*FI*/}
  509. /*FI*/C->_upper=((((T65*)C))->_upper/*12*/)+(1);
  510. /*[IRF3.6put*/{T65* C1=C;
  511. T0* b1=a1;
  512. int b2=(((T65*)C))->_upper/*12*/;
  513. ((((T65*)C1))->_storage/*4*/)[(b2)-((((T65*)C1))->_lower/*16*/)]=(b1);
  514. }/*]*/
  515. }
  516. T0* r65first(T65* C){
  517. T0* R=NULL;
  518. R=r65item(C,(((T65*)C))->_lower/*16*/);
  519. return R;
  520. }
  521. /*No:ARRAY[E_FEATURE].clear_all*/
  522. /*No:ARRAY[E_FEATURE].set_all_with*/
  523. void r495make(T495* C,int a1,int a2){
  524. int _needed=0;
  525. C->_lower=a1;
  526. C->_upper=a2;
  527. _needed=((a2)-(a1))+(1);
  528. /*IF*/if ((_needed)>(0)) {
  529. /*IF*/if (((((T495*)C))->_capacity/*4*/)<(_needed)) {
  530. /*IF*/if (((((T495*)C))->_capacity/*4*/)==(0)) {
  531. C->_storage=calloc(_needed,sizeof(T0*));
  532. }
  533. else {
  534. C->_storage=calloc(_needed,sizeof(T0*));
  535. }
  536. /*FI*/C->_capacity=_needed;
  537. }
  538. else {
  539. /*[IRF3.6clear_all*/{T495* C1=C;
  540. T0* __value=NULL;
  541. /*[IRF3.6set_all_with*/{T495* C2=C1;
  542. T0* c1=__value;
  543. r822set_all_with((((T495*)C2))->_storage/*0*/,c1,((((T495*)C2))->_upper/*8*/)-((((T495*)C2))->_lower/*12*/));
  544. }/*]*/
  545. }/*]*/
  546. }
  547. /*FI*/}
  548. /*FI*/}
  549. T0* r495item(T495* C,int a1){
  550. T0* R=NULL;
  551. R=((((T495*)C))->_storage/*0*/)[(a1)-((((T495*)C))->_lower/*12*/)];
  552. return R;
  553. }
  554. void r495resize(T495* C,int a1,int a2){
  555. int _mem=0;
  556. int _up=0;
  557. int _i=0;
  558. T0* _other=NULL;
  559. {T495*n=malloc(sizeof(*n));
  560. *n=M495;
  561. r495make(n,a1,a2);
  562. _other=(T0*)n;
  563. }
  564. _i=r2max((((T495*)C))->_lower/*12*/,(((T495*)((T495*)_other)))->_lower/*12*/);
  565. _up=r2min((((T495*)C))->_upper/*8*/,(((T495*)((T495*)_other)))->_upper/*8*/);
  566. while (!((_i)>(_up))) {
  567. /*[IRF3.6put*/{T495* C1=((T495*)_other);
  568. T0* b1=r495item(C,_i);
  569. int b2=_i;
  570. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  571. }/*]*/
  572. _i=(_i)+(1);
  573. }
  574. *((T495*)(C))=*((T495*)(_other));
  575. }
  576. /*No:ARRAY[E_FEATURE].storage*/
  577. /*No:ARRAY[E_FEATURE].capacity*/
  578. /*No:ARRAY[E_FEATURE].lower*/
  579. /*No:ARRAY[E_FEATURE].put*/
  580. /*No:ARRAY[E_FEATURE].upper*/
  581. void r495add_last(T495* C,T0* a1){
  582. int _new_capacity=0;
  583. /*IF*/if (((((T495*)C))->_capacity/*4*/)<((r495count(C))+(1))) {
  584. /*IF*/if (((((T495*)C))->_capacity/*4*/)==(0)) {
  585. C->_capacity=16;
  586. C->_storage=calloc((((T495*)C))->_capacity/*4*/,sizeof(T0*));
  587. }
  588. else {
  589. _new_capacity=(2)*((((T495*)C))->_capacity/*4*/);
  590. C->_storage=r822realloc((((T495*)C))->_storage/*0*/,(((T495*)C))->_capacity/*4*/,_new_capacity);
  591. C->_capacity=_new_capacity;
  592. }
  593. /*FI*/}
  594. /*FI*/C->_upper=((((T495*)C))->_upper/*8*/)+(1);
  595. /*[IRF3.6put*/{T495* C1=C;
  596. T0* b1=a1;
  597. int b2=(((T495*)C))->_upper/*8*/;
  598. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  599. }/*]*/
  600. }
  601. int r495count(T495* C){
  602. int R=0;
  603. R=(((((T495*)C))->_upper/*8*/)-((((T495*)C))->_lower/*12*/))+(1);
  604. return R;
  605. }
  606. T0* r263item(T263* C,int a1){
  607. T0* R=NULL;
  608. R=((((T263*)C))->_storage/*4*/)[(a1)-((((T263*)C))->_lower/*16*/)];
  609. return R;
  610. }
  611. /*No:ARRAY[WHEN_ITEM_2].storage*/
  612. T0* r263twin(T263* C){
  613. T0* R=NULL;
  614. R=malloc(sizeof(*C));
  615. *((T263*)R)=M263;
  616. r263copy(((T263*)R),((T0*)C));
  617. return R;
  618. }
  619. /*No:ARRAY[WHEN_ITEM_2].capacity*/
  620. void r263copy(T263* C,T0* a1){
  621. int _needed_capacity=0;
  622. C->_lower=(((T263*)((T263*)a1)))->_lower/*16*/;
  623. C->_upper=(((T263*)((T263*)a1)))->_upper/*12*/;
  624. _needed_capacity=(((((T263*)C))->_upper/*12*/)-((((T263*)C))->_lower/*16*/))+(1);
  625. /*IF*/if (((((T263*)C))->_capacity/*8*/)<(_needed_capacity)) {
  626. C->_capacity=_needed_capacity;
  627. C->_storage=calloc((((T263*)C))->_capacity/*8*/,sizeof(T0*));
  628. }
  629. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  630. r533copy_from((((T263*)C))->_storage/*4*/,(((T263*)((T263*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  631. }
  632. /*FI*/}
  633. /*No:ARRAY[WHEN_ITEM_2].lower*/
  634. /*No:ARRAY[WHEN_ITEM_2].put*/
  635. /*No:ARRAY[WHEN_ITEM_2].upper*/
  636. int r263count(T263* C){
  637. int R=0;
  638. R=(((((T263*)C))->_upper/*12*/)-((((T263*)C))->_lower/*16*/))+(1);
  639. return R;
  640. }
  641. void r263add_last(T263* C,T0* a1){
  642. int _new_capacity=0;
  643. /*IF*/if (((((T263*)C))->_capacity/*8*/)<((r263count(C))+(1))) {
  644. /*IF*/if (((((T263*)C))->_capacity/*8*/)==(0)) {
  645. C->_capacity=16;
  646. C->_storage=calloc((((T263*)C))->_capacity/*8*/,sizeof(T0*));
  647. }
  648. else {
  649. _new_capacity=(2)*((((T263*)C))->_capacity/*8*/);
  650. C->_storage=r533realloc((((T263*)C))->_storage/*4*/,(((T263*)C))->_capacity/*8*/,_new_capacity);
  651. C->_capacity=_new_capacity;
  652. }
  653. /*FI*/}
  654. /*FI*/C->_upper=((((T263*)C))->_upper/*12*/)+(1);
  655. /*[IRF3.6put*/{T263* C1=C;
  656. T0* b1=a1;
  657. int b2=(((T263*)C))->_upper/*12*/;
  658. ((((T263*)C1))->_storage/*4*/)[(b2)-((((T263*)C1))->_lower/*16*/)]=(b1);
  659. }/*]*/
  660. }
  661. T0* r272item(T272* C,int a1){
  662. T0* R=NULL;
  663. R=((((T272*)C))->_storage/*4*/)[a1];
  664. return R;
  665. }
  666. /*No:FIXED_ARRAY[TYPE].storage*/
  667. /*No:FIXED_ARRAY[TYPE].capacity*/
  668. void r272with_capacity(T272* C,int a1){
  669. /*IF*/if (((((T272*)C))->_capacity/*8*/)<(a1)) {
  670. C->_storage=calloc(a1,sizeof(T0*));
  671. C->_capacity=a1;
  672. }
  673. /*FI*/C->_upper=-(1);
  674. }
  675. /*No:FIXED_ARRAY[TYPE].put*/
  676. /*No:FIXED_ARRAY[TYPE].upper*/
  677. void r272add_last(T272* C,T0* a1){
  678. int _new_capacity=0;
  679. /*IF*/if ((((((T272*)C))->_upper/*12*/)+(1))<=(((((T272*)C))->_capacity/*8*/)-(1))) {
  680. C->_upper=((((T272*)C))->_upper/*12*/)+(1);
  681. }
  682.  else if (((((T272*)C))->_capacity/*8*/)==(0)) {
  683. C->_storage=calloc(2,sizeof(T0*));
  684. C->_capacity=2;
  685. C->_upper=0;
  686. }
  687. else {
  688. _new_capacity=(2)*((((T272*)C))->_capacity/*8*/);
  689. C->_storage=r770realloc((((T272*)C))->_storage/*4*/,(((T272*)C))->_capacity/*8*/,_new_capacity);
  690. C->_capacity=_new_capacity;
  691. C->_upper=((((T272*)C))->_upper/*12*/)+(1);
  692. }
  693. /*FI*//*[IRF3.6put*/{T272* C1=C;
  694. T0* b1=a1;
  695. int b2=(((T272*)C))->_upper/*12*/;
  696. ((((T272*)C1))->_storage/*4*/)[b2]=(b1);
  697. }/*]*/
  698. }
  699. T0* r701item(T701* C,int a1){
  700. T0* R=NULL;
  701. R=((((T701*)C))->_storage/*0*/)[(a1)-((((T701*)C))->_lower/*12*/)];
  702. return R;
  703. }
  704. /*No:ARRAY[TYPE].storage*/
  705. T0* r701twin(T701* C){
  706. T0* R=NULL;
  707. R=malloc(sizeof(*C));
  708. *((T701*)R)=M701;
  709. r701copy(((T701*)R),((T0*)C));
  710. return R;
  711. }
  712. /*No:ARRAY[TYPE].capacity*/
  713. void r701copy(T701* C,T0* a1){
  714. int _needed_capacity=0;
  715. C->_lower=(((T701*)((T701*)a1)))->_lower/*12*/;
  716. C->_upper=(((T701*)((T701*)a1)))->_upper/*8*/;
  717. _needed_capacity=(((((T701*)C))->_upper/*8*/)-((((T701*)C))->_lower/*12*/))+(1);
  718. /*IF*/if (((((T701*)C))->_capacity/*4*/)<(_needed_capacity)) {
  719. C->_capacity=_needed_capacity;
  720. C->_storage=calloc((((T701*)C))->_capacity/*4*/,sizeof(T0*));
  721. }
  722. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  723. r770copy_from((((T701*)C))->_storage/*0*/,(((T701*)((T701*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  724. }
  725. /*FI*/}
  726. /*No:ARRAY[TYPE].lower*/
  727. /*No:ARRAY[TYPE].put*/
  728. /*No:ARRAY[TYPE].upper*/
  729. int r701count(T701* C){
  730. int R=0;
  731. R=(((((T701*)C))->_upper/*8*/)-((((T701*)C))->_lower/*12*/))+(1);
  732. return R;
  733. }
  734. void r701add_last(T701* C,T0* a1){
  735. int _new_capacity=0;
  736. /*IF*/if (((((T701*)C))->_capacity/*4*/)<((r701count(C))+(1))) {
  737. /*IF*/if (((((T701*)C))->_capacity/*4*/)==(0)) {
  738. C->_capacity=16;
  739. C->_storage=calloc((((T701*)C))->_capacity/*4*/,sizeof(T0*));
  740. }
  741. else {
  742. _new_capacity=(2)*((((T701*)C))->_capacity/*4*/);
  743. C->_storage=r770realloc((((T701*)C))->_storage/*0*/,(((T701*)C))->_capacity/*4*/,_new_capacity);
  744. C->_capacity=_new_capacity;
  745. }
  746. /*FI*/}
  747. /*FI*/C->_upper=((((T701*)C))->_upper/*8*/)+(1);
  748. /*[IRF3.6put*/{T701* C1=C;
  749. T0* b1=a1;
  750. int b2=(((T701*)C))->_upper/*8*/;
  751. ((((T701*)C1))->_storage/*0*/)[(b2)-((((T701*)C1))->_lower/*12*/)]=(b1);
  752. }/*]*/
  753. }
  754.  
  755.